// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.payable;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.Payable;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(Payable.class)
@Setter
@Getter
public class PayableSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "Payable".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("supplierId", "s");
    map.put("warehouse", "w");
    map.put("settlementOrg", "do");
    map.put("payOrg", "sd");
    map.put("purchasesOrg", "do2");
    map.put("preparedBy", "su");
    map.put("verifier", "su2");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 单据编号(模糊搜索)
   */
  private String payCode;

  /**
   * 单据编号 比较(eq)
   */
  private String payCodeEq;
  /**
   * 单据编号 比较(neq)
   */
  private String payCodeNeq;
  /**
   * 单据编号 比较(gt)
   */
  private String payCodeGt;
  /**
   * 单据编号 比较(gte)
   */
  private String payCodeGte;
  /**
   * 单据编号 比较(lt)
   */
  private String payCodeLt;
  /**
   * 单据编号 比较(lte)
   */
  private String payCodeLte;
  /**
   * 单据编号 比较(contains)
   */
  private String payCodeContains;
  /**
   * 单据编号 比较(notcontains)
   */
  private String payCodeNotcontains;
  /**
   * 单据编号 比较(startswith)
   */
  private String payCodeStartswith;
  /**
   * 单据编号 比较(endswith)
   */
  private String payCodeEndswith;
  /**
   * 单据编号 比较(isnull)
   */
  private Boolean payCodeIsnull;
  /**
   * 单据编号 比较(isnotnull)
   */
  private Boolean payCodeIsnotnull;

  /**
   * 单据编号(精确搜索)
   */
  private List<String> payCodeInList;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 供应商
   */
  private Long supplierId;

  /**
   * 供应商 比较(eq)
   */
  private Long supplierIdEq;
  /**
   * 供应商 比较(neq)
   */
  private Long supplierIdNeq;
  /**
   * 供应商 比较(gt)
   */
  private Long supplierIdGt;
  /**
   * 供应商 比较(gte)
   */
  private Long supplierIdGte;
  /**
   * 供应商 比较(lt)
   */
  private Long supplierIdLt;
  /**
   * 供应商 比较(lte)
   */
  private Long supplierIdLte;
  /**
   * 供应商 比较(contains)
   */
  private Long supplierIdContains;
  /**
   * 供应商 比较(notcontains)
   */
  private Long supplierIdNotcontains;
  /**
   * 供应商 比较(startswith)
   */
  private Long supplierIdStartswith;
  /**
   * 供应商 比较(endswith)
   */
  private Long supplierIdEndswith;
  /**
   * 供应商 比较(isnull)
   */
  private Boolean supplierIdIsnull;
  /**
   * 供应商 比较(isnotnull)
   */
  private Boolean supplierIdIsnotnull;
  /**
   * 供应商的供应商简称 比较(eq)
   */
  private String supplierIdSupplierNameEq;
  /**
   * 供应商的供应商简称 比较(neq)
   */
  private String supplierIdSupplierNameNeq;
  /**
   * 供应商的供应商简称 比较(gt)
   */
  private String supplierIdSupplierNameGt;
  /**
   * 供应商的供应商简称 比较(gte)
   */
  private String supplierIdSupplierNameGte;
  /**
   * 供应商的供应商简称 比较(lt)
   */
  private String supplierIdSupplierNameLt;
  /**
   * 供应商的供应商简称 比较(lte)
   */
  private String supplierIdSupplierNameLte;
  /**
   * 供应商的供应商简称 比较(contains)
   */
  private String supplierIdSupplierNameContains;
  /**
   * 供应商的供应商简称 比较(notcontains)
   */
  private String supplierIdSupplierNameNotcontains;
  /**
   * 供应商的供应商简称 比较(startswith)
   */
  private String supplierIdSupplierNameStartswith;
  /**
   * 供应商的供应商简称 比较(endswith)
   */
  private String supplierIdSupplierNameEndswith;
  /**
   * 供应商的供应商简称 比较(isnull)
   */
  private Boolean supplierIdSupplierNameIsnull;
  /**
   * 供应商的供应商简称 比较(isnotnull)
   */
  private Boolean supplierIdSupplierNameIsnotnull;

  /**
   * 供应商(范围搜索)
   */
  private List<Long> supplierIdInList;

  /**
   * 供应商名称(模糊搜索)
   */
  private String supplierName;

  /**
   * 供应商名称 比较(eq)
   */
  private String supplierNameEq;
  /**
   * 供应商名称 比较(neq)
   */
  private String supplierNameNeq;
  /**
   * 供应商名称 比较(gt)
   */
  private String supplierNameGt;
  /**
   * 供应商名称 比较(gte)
   */
  private String supplierNameGte;
  /**
   * 供应商名称 比较(lt)
   */
  private String supplierNameLt;
  /**
   * 供应商名称 比较(lte)
   */
  private String supplierNameLte;
  /**
   * 供应商名称 比较(contains)
   */
  private String supplierNameContains;
  /**
   * 供应商名称 比较(notcontains)
   */
  private String supplierNameNotcontains;
  /**
   * 供应商名称 比较(startswith)
   */
  private String supplierNameStartswith;
  /**
   * 供应商名称 比较(endswith)
   */
  private String supplierNameEndswith;
  /**
   * 供应商名称 比较(isnull)
   */
  private Boolean supplierNameIsnull;
  /**
   * 供应商名称 比较(isnotnull)
   */
  private Boolean supplierNameIsnotnull;

  /**
   * 供应商名称(精确搜索)
   */
  private List<String> supplierNameInList;

  /**
   * 仓库
   */
  private Long warehouse;

  /**
   * 仓库 比较(eq)
   */
  private Long warehouseEq;
  /**
   * 仓库 比较(neq)
   */
  private Long warehouseNeq;
  /**
   * 仓库 比较(gt)
   */
  private Long warehouseGt;
  /**
   * 仓库 比较(gte)
   */
  private Long warehouseGte;
  /**
   * 仓库 比较(lt)
   */
  private Long warehouseLt;
  /**
   * 仓库 比较(lte)
   */
  private Long warehouseLte;
  /**
   * 仓库 比较(contains)
   */
  private Long warehouseContains;
  /**
   * 仓库 比较(notcontains)
   */
  private Long warehouseNotcontains;
  /**
   * 仓库 比较(startswith)
   */
  private Long warehouseStartswith;
  /**
   * 仓库 比较(endswith)
   */
  private Long warehouseEndswith;
  /**
   * 仓库 比较(isnull)
   */
  private Boolean warehouseIsnull;
  /**
   * 仓库 比较(isnotnull)
   */
  private Boolean warehouseIsnotnull;
  /**
   * 仓库的仓库名称 比较(eq)
   */
  private String warehouseNameEq;
  /**
   * 仓库的仓库名称 比较(neq)
   */
  private String warehouseNameNeq;
  /**
   * 仓库的仓库名称 比较(gt)
   */
  private String warehouseNameGt;
  /**
   * 仓库的仓库名称 比较(gte)
   */
  private String warehouseNameGte;
  /**
   * 仓库的仓库名称 比较(lt)
   */
  private String warehouseNameLt;
  /**
   * 仓库的仓库名称 比较(lte)
   */
  private String warehouseNameLte;
  /**
   * 仓库的仓库名称 比较(contains)
   */
  private String warehouseNameContains;
  /**
   * 仓库的仓库名称 比较(notcontains)
   */
  private String warehouseNameNotcontains;
  /**
   * 仓库的仓库名称 比较(startswith)
   */
  private String warehouseNameStartswith;
  /**
   * 仓库的仓库名称 比较(endswith)
   */
  private String warehouseNameEndswith;
  /**
   * 仓库的仓库名称 比较(isnull)
   */
  private Boolean warehouseNameIsnull;
  /**
   * 仓库的仓库名称 比较(isnotnull)
   */
  private Boolean warehouseNameIsnotnull;

  /**
   * 仓库(范围搜索)
   */
  private List<Long> warehouseInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 结算组织
   */
  private Long settlementOrg;

  /**
   * 结算组织 比较(eq)
   */
  private Long settlementOrgEq;
  /**
   * 结算组织 比较(neq)
   */
  private Long settlementOrgNeq;
  /**
   * 结算组织 比较(gt)
   */
  private Long settlementOrgGt;
  /**
   * 结算组织 比较(gte)
   */
  private Long settlementOrgGte;
  /**
   * 结算组织 比较(lt)
   */
  private Long settlementOrgLt;
  /**
   * 结算组织 比较(lte)
   */
  private Long settlementOrgLte;
  /**
   * 结算组织 比较(contains)
   */
  private Long settlementOrgContains;
  /**
   * 结算组织 比较(notcontains)
   */
  private Long settlementOrgNotcontains;
  /**
   * 结算组织 比较(startswith)
   */
  private Long settlementOrgStartswith;
  /**
   * 结算组织 比较(endswith)
   */
  private Long settlementOrgEndswith;
  /**
   * 结算组织 比较(isnull)
   */
  private Boolean settlementOrgIsnull;
  /**
   * 结算组织 比较(isnotnull)
   */
  private Boolean settlementOrgIsnotnull;
  /**
   * 结算组织的名称 比较(eq)
   */
  private String settlementOrgNameEq;
  /**
   * 结算组织的名称 比较(neq)
   */
  private String settlementOrgNameNeq;
  /**
   * 结算组织的名称 比较(gt)
   */
  private String settlementOrgNameGt;
  /**
   * 结算组织的名称 比较(gte)
   */
  private String settlementOrgNameGte;
  /**
   * 结算组织的名称 比较(lt)
   */
  private String settlementOrgNameLt;
  /**
   * 结算组织的名称 比较(lte)
   */
  private String settlementOrgNameLte;
  /**
   * 结算组织的名称 比较(contains)
   */
  private String settlementOrgNameContains;
  /**
   * 结算组织的名称 比较(notcontains)
   */
  private String settlementOrgNameNotcontains;
  /**
   * 结算组织的名称 比较(startswith)
   */
  private String settlementOrgNameStartswith;
  /**
   * 结算组织的名称 比较(endswith)
   */
  private String settlementOrgNameEndswith;
  /**
   * 结算组织的名称 比较(isnull)
   */
  private Boolean settlementOrgNameIsnull;
  /**
   * 结算组织的名称 比较(isnotnull)
   */
  private Boolean settlementOrgNameIsnotnull;

  /**
   * 结算组织(范围搜索)
   */
  private List<Long> settlementOrgInList;

  /**
   * 付款组织
   */
  private Long payOrg;

  /**
   * 付款组织 比较(eq)
   */
  private Long payOrgEq;
  /**
   * 付款组织 比较(neq)
   */
  private Long payOrgNeq;
  /**
   * 付款组织 比较(gt)
   */
  private Long payOrgGt;
  /**
   * 付款组织 比较(gte)
   */
  private Long payOrgGte;
  /**
   * 付款组织 比较(lt)
   */
  private Long payOrgLt;
  /**
   * 付款组织 比较(lte)
   */
  private Long payOrgLte;
  /**
   * 付款组织 比较(contains)
   */
  private Long payOrgContains;
  /**
   * 付款组织 比较(notcontains)
   */
  private Long payOrgNotcontains;
  /**
   * 付款组织 比较(startswith)
   */
  private Long payOrgStartswith;
  /**
   * 付款组织 比较(endswith)
   */
  private Long payOrgEndswith;
  /**
   * 付款组织 比较(isnull)
   */
  private Boolean payOrgIsnull;
  /**
   * 付款组织 比较(isnotnull)
   */
  private Boolean payOrgIsnotnull;
  /**
   * 付款组织的部门名称 比较(eq)
   */
  private String payOrgNameEq;
  /**
   * 付款组织的部门名称 比较(neq)
   */
  private String payOrgNameNeq;
  /**
   * 付款组织的部门名称 比较(gt)
   */
  private String payOrgNameGt;
  /**
   * 付款组织的部门名称 比较(gte)
   */
  private String payOrgNameGte;
  /**
   * 付款组织的部门名称 比较(lt)
   */
  private String payOrgNameLt;
  /**
   * 付款组织的部门名称 比较(lte)
   */
  private String payOrgNameLte;
  /**
   * 付款组织的部门名称 比较(contains)
   */
  private String payOrgNameContains;
  /**
   * 付款组织的部门名称 比较(notcontains)
   */
  private String payOrgNameNotcontains;
  /**
   * 付款组织的部门名称 比较(startswith)
   */
  private String payOrgNameStartswith;
  /**
   * 付款组织的部门名称 比较(endswith)
   */
  private String payOrgNameEndswith;
  /**
   * 付款组织的部门名称 比较(isnull)
   */
  private Boolean payOrgNameIsnull;
  /**
   * 付款组织的部门名称 比较(isnotnull)
   */
  private Boolean payOrgNameIsnotnull;

  /**
   * 付款组织(范围搜索)
   */
  private List<Long> payOrgInList;

  /**
   * 采购组织
   */
  private Long purchasesOrg;

  /**
   * 采购组织 比较(eq)
   */
  private Long purchasesOrgEq;
  /**
   * 采购组织 比较(neq)
   */
  private Long purchasesOrgNeq;
  /**
   * 采购组织 比较(gt)
   */
  private Long purchasesOrgGt;
  /**
   * 采购组织 比较(gte)
   */
  private Long purchasesOrgGte;
  /**
   * 采购组织 比较(lt)
   */
  private Long purchasesOrgLt;
  /**
   * 采购组织 比较(lte)
   */
  private Long purchasesOrgLte;
  /**
   * 采购组织 比较(contains)
   */
  private Long purchasesOrgContains;
  /**
   * 采购组织 比较(notcontains)
   */
  private Long purchasesOrgNotcontains;
  /**
   * 采购组织 比较(startswith)
   */
  private Long purchasesOrgStartswith;
  /**
   * 采购组织 比较(endswith)
   */
  private Long purchasesOrgEndswith;
  /**
   * 采购组织 比较(isnull)
   */
  private Boolean purchasesOrgIsnull;
  /**
   * 采购组织 比较(isnotnull)
   */
  private Boolean purchasesOrgIsnotnull;
  /**
   * 采购组织的名称 比较(eq)
   */
  private String purchasesOrgNameEq;
  /**
   * 采购组织的名称 比较(neq)
   */
  private String purchasesOrgNameNeq;
  /**
   * 采购组织的名称 比较(gt)
   */
  private String purchasesOrgNameGt;
  /**
   * 采购组织的名称 比较(gte)
   */
  private String purchasesOrgNameGte;
  /**
   * 采购组织的名称 比较(lt)
   */
  private String purchasesOrgNameLt;
  /**
   * 采购组织的名称 比较(lte)
   */
  private String purchasesOrgNameLte;
  /**
   * 采购组织的名称 比较(contains)
   */
  private String purchasesOrgNameContains;
  /**
   * 采购组织的名称 比较(notcontains)
   */
  private String purchasesOrgNameNotcontains;
  /**
   * 采购组织的名称 比较(startswith)
   */
  private String purchasesOrgNameStartswith;
  /**
   * 采购组织的名称 比较(endswith)
   */
  private String purchasesOrgNameEndswith;
  /**
   * 采购组织的名称 比较(isnull)
   */
  private Boolean purchasesOrgNameIsnull;
  /**
   * 采购组织的名称 比较(isnotnull)
   */
  private Boolean purchasesOrgNameIsnotnull;

  /**
   * 采购组织(范围搜索)
   */
  private List<Long> purchasesOrgInList;

  /**
   * 最早入库日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date businessDateStart;

  /**
   * 最晚入库日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date businessDateEnd;

  /**
   * 入库日期 比较(eq)
   */
  private Date businessDateEq;
  /**
   * 入库日期 比较(neq)
   */
  private Date businessDateNeq;
  /**
   * 入库日期 比较(gt)
   */
  private Date businessDateGt;
  /**
   * 入库日期 比较(gte)
   */
  private Date businessDateGte;
  /**
   * 入库日期 比较(lt)
   */
  private Date businessDateLt;
  /**
   * 入库日期 比较(lte)
   */
  private Date businessDateLte;
  /**
   * 入库日期 比较(contains)
   */
  private Date businessDateContains;
  /**
   * 入库日期 比较(notcontains)
   */
  private Date businessDateNotcontains;
  /**
   * 入库日期 比较(startswith)
   */
  private Date businessDateStartswith;
  /**
   * 入库日期 比较(endswith)
   */
  private Date businessDateEndswith;
  /**
   * 入库日期 比较(isnull)
   */
  private Boolean businessDateIsnull;
  /**
   * 入库日期 比较(isnotnull)
   */
  private Boolean businessDateIsnotnull;

  /**
   * 最早审核日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date settlementDateStart;

  /**
   * 最晚审核日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date settlementDateEnd;

  /**
   * 审核日期 比较(eq)
   */
  private Date settlementDateEq;
  /**
   * 审核日期 比较(neq)
   */
  private Date settlementDateNeq;
  /**
   * 审核日期 比较(gt)
   */
  private Date settlementDateGt;
  /**
   * 审核日期 比较(gte)
   */
  private Date settlementDateGte;
  /**
   * 审核日期 比较(lt)
   */
  private Date settlementDateLt;
  /**
   * 审核日期 比较(lte)
   */
  private Date settlementDateLte;
  /**
   * 审核日期 比较(contains)
   */
  private Date settlementDateContains;
  /**
   * 审核日期 比较(notcontains)
   */
  private Date settlementDateNotcontains;
  /**
   * 审核日期 比较(startswith)
   */
  private Date settlementDateStartswith;
  /**
   * 审核日期 比较(endswith)
   */
  private Date settlementDateEndswith;
  /**
   * 审核日期 比较(isnull)
   */
  private Boolean settlementDateIsnull;
  /**
   * 审核日期 比较(isnotnull)
   */
  private Boolean settlementDateIsnotnull;

  /**
   * 状态
   */
  private String stauts;

  /**
   * 状态 比较(eq)
   */
  private String stautsEq;
  /**
   * 状态 比较(neq)
   */
  private String stautsNeq;
  /**
   * 状态 比较(gt)
   */
  private String stautsGt;
  /**
   * 状态 比较(gte)
   */
  private String stautsGte;
  /**
   * 状态 比较(lt)
   */
  private String stautsLt;
  /**
   * 状态 比较(lte)
   */
  private String stautsLte;
  /**
   * 状态 比较(contains)
   */
  private String stautsContains;
  /**
   * 状态 比较(notcontains)
   */
  private String stautsNotcontains;
  /**
   * 状态 比较(startswith)
   */
  private String stautsStartswith;
  /**
   * 状态 比较(endswith)
   */
  private String stautsEndswith;
  /**
   * 状态 比较(isnull)
   */
  private Boolean stautsIsnull;
  /**
   * 状态 比较(isnotnull)
   */
  private Boolean stautsIsnotnull;

  /**
   * 状态(精确搜索)
   */
  private List<String> stautsInList;

  /**
   * 备注(模糊搜索)
   */
  private String remarks;

  /**
   * 备注 比较(eq)
   */
  private String remarksEq;
  /**
   * 备注 比较(neq)
   */
  private String remarksNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarksGt;
  /**
   * 备注 比较(gte)
   */
  private String remarksGte;
  /**
   * 备注 比较(lt)
   */
  private String remarksLt;
  /**
   * 备注 比较(lte)
   */
  private String remarksLte;
  /**
   * 备注 比较(contains)
   */
  private String remarksContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarksNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarksStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarksEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarksIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarksIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarksInList;

  /**
   * 驳回原因(模糊搜索)
   */
  private String rejectRemark;

  /**
   * 驳回原因 比较(eq)
   */
  private String rejectRemarkEq;
  /**
   * 驳回原因 比较(neq)
   */
  private String rejectRemarkNeq;
  /**
   * 驳回原因 比较(gt)
   */
  private String rejectRemarkGt;
  /**
   * 驳回原因 比较(gte)
   */
  private String rejectRemarkGte;
  /**
   * 驳回原因 比较(lt)
   */
  private String rejectRemarkLt;
  /**
   * 驳回原因 比较(lte)
   */
  private String rejectRemarkLte;
  /**
   * 驳回原因 比较(contains)
   */
  private String rejectRemarkContains;
  /**
   * 驳回原因 比较(notcontains)
   */
  private String rejectRemarkNotcontains;
  /**
   * 驳回原因 比较(startswith)
   */
  private String rejectRemarkStartswith;
  /**
   * 驳回原因 比较(endswith)
   */
  private String rejectRemarkEndswith;
  /**
   * 驳回原因 比较(isnull)
   */
  private Boolean rejectRemarkIsnull;
  /**
   * 驳回原因 比较(isnotnull)
   */
  private Boolean rejectRemarkIsnotnull;

  /**
   * 驳回原因(精确搜索)
   */
  private List<String> rejectRemarkInList;

  /**
   * 推送状态
   */
  private String pushStatus;

  /**
   * 推送状态 比较(eq)
   */
  private String pushStatusEq;
  /**
   * 推送状态 比较(neq)
   */
  private String pushStatusNeq;
  /**
   * 推送状态 比较(gt)
   */
  private String pushStatusGt;
  /**
   * 推送状态 比较(gte)
   */
  private String pushStatusGte;
  /**
   * 推送状态 比较(lt)
   */
  private String pushStatusLt;
  /**
   * 推送状态 比较(lte)
   */
  private String pushStatusLte;
  /**
   * 推送状态 比较(contains)
   */
  private String pushStatusContains;
  /**
   * 推送状态 比较(notcontains)
   */
  private String pushStatusNotcontains;
  /**
   * 推送状态 比较(startswith)
   */
  private String pushStatusStartswith;
  /**
   * 推送状态 比较(endswith)
   */
  private String pushStatusEndswith;
  /**
   * 推送状态 比较(isnull)
   */
  private Boolean pushStatusIsnull;
  /**
   * 推送状态 比较(isnotnull)
   */
  private Boolean pushStatusIsnotnull;

  /**
   * 推送状态(精确搜索)
   */
  private List<String> pushStatusInList;

  /**
   * 结果信息(模糊搜索)
   */
  private String resultInfo;

  /**
   * 结果信息 比较(eq)
   */
  private String resultInfoEq;
  /**
   * 结果信息 比较(neq)
   */
  private String resultInfoNeq;
  /**
   * 结果信息 比较(gt)
   */
  private String resultInfoGt;
  /**
   * 结果信息 比较(gte)
   */
  private String resultInfoGte;
  /**
   * 结果信息 比较(lt)
   */
  private String resultInfoLt;
  /**
   * 结果信息 比较(lte)
   */
  private String resultInfoLte;
  /**
   * 结果信息 比较(contains)
   */
  private String resultInfoContains;
  /**
   * 结果信息 比较(notcontains)
   */
  private String resultInfoNotcontains;
  /**
   * 结果信息 比较(startswith)
   */
  private String resultInfoStartswith;
  /**
   * 结果信息 比较(endswith)
   */
  private String resultInfoEndswith;
  /**
   * 结果信息 比较(isnull)
   */
  private Boolean resultInfoIsnull;
  /**
   * 结果信息 比较(isnotnull)
   */
  private Boolean resultInfoIsnotnull;

  /**
   * 结果信息(精确搜索)
   */
  private List<String> resultInfoInList;

  /**
   * 金蝶凭证号(模糊搜索)
   */
  private String voucherNo;

  /**
   * 金蝶凭证号 比较(eq)
   */
  private String voucherNoEq;
  /**
   * 金蝶凭证号 比较(neq)
   */
  private String voucherNoNeq;
  /**
   * 金蝶凭证号 比较(gt)
   */
  private String voucherNoGt;
  /**
   * 金蝶凭证号 比较(gte)
   */
  private String voucherNoGte;
  /**
   * 金蝶凭证号 比较(lt)
   */
  private String voucherNoLt;
  /**
   * 金蝶凭证号 比较(lte)
   */
  private String voucherNoLte;
  /**
   * 金蝶凭证号 比较(contains)
   */
  private String voucherNoContains;
  /**
   * 金蝶凭证号 比较(notcontains)
   */
  private String voucherNoNotcontains;
  /**
   * 金蝶凭证号 比较(startswith)
   */
  private String voucherNoStartswith;
  /**
   * 金蝶凭证号 比较(endswith)
   */
  private String voucherNoEndswith;
  /**
   * 金蝶凭证号 比较(isnull)
   */
  private Boolean voucherNoIsnull;
  /**
   * 金蝶凭证号 比较(isnotnull)
   */
  private Boolean voucherNoIsnotnull;

  /**
   * 金蝶凭证号(精确搜索)
   */
  private List<String> voucherNoInList;

  /**
   * 产品类型
   */
  private String productType;

  /**
   * 产品类型 比较(eq)
   */
  private String productTypeEq;
  /**
   * 产品类型 比较(neq)
   */
  private String productTypeNeq;
  /**
   * 产品类型 比较(gt)
   */
  private String productTypeGt;
  /**
   * 产品类型 比较(gte)
   */
  private String productTypeGte;
  /**
   * 产品类型 比较(lt)
   */
  private String productTypeLt;
  /**
   * 产品类型 比较(lte)
   */
  private String productTypeLte;
  /**
   * 产品类型 比较(contains)
   */
  private String productTypeContains;
  /**
   * 产品类型 比较(notcontains)
   */
  private String productTypeNotcontains;
  /**
   * 产品类型 比较(startswith)
   */
  private String productTypeStartswith;
  /**
   * 产品类型 比较(endswith)
   */
  private String productTypeEndswith;
  /**
   * 产品类型 比较(isnull)
   */
  private Boolean productTypeIsnull;
  /**
   * 产品类型 比较(isnotnull)
   */
  private Boolean productTypeIsnotnull;

  /**
   * 产品类型(精确搜索)
   */
  private List<String> productTypeInList;

  /**
   * 采购单号(模糊搜索)
   */
  private String purchaseOrder;

  /**
   * 采购单号 比较(eq)
   */
  private String purchaseOrderEq;
  /**
   * 采购单号 比较(neq)
   */
  private String purchaseOrderNeq;
  /**
   * 采购单号 比较(gt)
   */
  private String purchaseOrderGt;
  /**
   * 采购单号 比较(gte)
   */
  private String purchaseOrderGte;
  /**
   * 采购单号 比较(lt)
   */
  private String purchaseOrderLt;
  /**
   * 采购单号 比较(lte)
   */
  private String purchaseOrderLte;
  /**
   * 采购单号 比较(contains)
   */
  private String purchaseOrderContains;
  /**
   * 采购单号 比较(notcontains)
   */
  private String purchaseOrderNotcontains;
  /**
   * 采购单号 比较(startswith)
   */
  private String purchaseOrderStartswith;
  /**
   * 采购单号 比较(endswith)
   */
  private String purchaseOrderEndswith;
  /**
   * 采购单号 比较(isnull)
   */
  private Boolean purchaseOrderIsnull;
  /**
   * 采购单号 比较(isnotnull)
   */
  private Boolean purchaseOrderIsnotnull;

  /**
   * 采购单号(精确搜索)
   */
  private List<String> purchaseOrderInList;

  /**
   * 入库单号(模糊搜索)
   */
  private String warehouseSn;

  /**
   * 入库单号 比较(eq)
   */
  private String warehouseSnEq;
  /**
   * 入库单号 比较(neq)
   */
  private String warehouseSnNeq;
  /**
   * 入库单号 比较(gt)
   */
  private String warehouseSnGt;
  /**
   * 入库单号 比较(gte)
   */
  private String warehouseSnGte;
  /**
   * 入库单号 比较(lt)
   */
  private String warehouseSnLt;
  /**
   * 入库单号 比较(lte)
   */
  private String warehouseSnLte;
  /**
   * 入库单号 比较(contains)
   */
  private String warehouseSnContains;
  /**
   * 入库单号 比较(notcontains)
   */
  private String warehouseSnNotcontains;
  /**
   * 入库单号 比较(startswith)
   */
  private String warehouseSnStartswith;
  /**
   * 入库单号 比较(endswith)
   */
  private String warehouseSnEndswith;
  /**
   * 入库单号 比较(isnull)
   */
  private Boolean warehouseSnIsnull;
  /**
   * 入库单号 比较(isnotnull)
   */
  private Boolean warehouseSnIsnotnull;

  /**
   * 入库单号(精确搜索)
   */
  private List<String> warehouseSnInList;

  /**
   * 结款状态
   */
  private String settlementStatus;

  /**
   * 结款状态 比较(eq)
   */
  private String settlementStatusEq;
  /**
   * 结款状态 比较(neq)
   */
  private String settlementStatusNeq;
  /**
   * 结款状态 比较(gt)
   */
  private String settlementStatusGt;
  /**
   * 结款状态 比较(gte)
   */
  private String settlementStatusGte;
  /**
   * 结款状态 比较(lt)
   */
  private String settlementStatusLt;
  /**
   * 结款状态 比较(lte)
   */
  private String settlementStatusLte;
  /**
   * 结款状态 比较(contains)
   */
  private String settlementStatusContains;
  /**
   * 结款状态 比较(notcontains)
   */
  private String settlementStatusNotcontains;
  /**
   * 结款状态 比较(startswith)
   */
  private String settlementStatusStartswith;
  /**
   * 结款状态 比较(endswith)
   */
  private String settlementStatusEndswith;
  /**
   * 结款状态 比较(isnull)
   */
  private Boolean settlementStatusIsnull;
  /**
   * 结款状态 比较(isnotnull)
   */
  private Boolean settlementStatusIsnotnull;

  /**
   * 结款状态(精确搜索)
   */
  private List<String> settlementStatusInList;

  /**
   * categoryId
   */
  private String categoryId;

  /**
   * categoryId 比较(eq)
   */
  private String categoryIdEq;
  /**
   * categoryId 比较(neq)
   */
  private String categoryIdNeq;
  /**
   * categoryId 比较(gt)
   */
  private String categoryIdGt;
  /**
   * categoryId 比较(gte)
   */
  private String categoryIdGte;
  /**
   * categoryId 比较(lt)
   */
  private String categoryIdLt;
  /**
   * categoryId 比较(lte)
   */
  private String categoryIdLte;
  /**
   * categoryId 比较(contains)
   */
  private String categoryIdContains;
  /**
   * categoryId 比较(notcontains)
   */
  private String categoryIdNotcontains;
  /**
   * categoryId 比较(startswith)
   */
  private String categoryIdStartswith;
  /**
   * categoryId 比较(endswith)
   */
  private String categoryIdEndswith;
  /**
   * categoryId 比较(isnull)
   */
  private Boolean categoryIdIsnull;
  /**
   * categoryId 比较(isnotnull)
   */
  private Boolean categoryIdIsnotnull;

  /**
   * categoryId(精确搜索)
   */
  private List<String> categoryIdInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
